// #pragma once

// #include <iostream>
// #include <queue>
// #include <pthread.h>
// #include <functional>
// #include <cstdio>
// #include <cstring>

// using namespace std;

// using std::cerr;
// using std::cout;
// using std::endl;

// const std::string oper = "+-*/%";
// int my_math(int x, int y, char op)
// {
//     int result = 0;
//     switch (op)
//     {
//     case '+':
//         // return x + y;//return 不需要break
//         result = x + y;
//         break;
//     case '-':
//         // return x - y;
//         result = x - y;

//         break;
//     case '*':
//         // return x * y;
//         result = x * y;

//         break;
//     case '/':
//     {
//         if (y == 0)
//         {
//             cerr << "div zero error!" << endl;
//             result = -1;
//         }
//         else
//             result = x / y;
//     }
//     break;
//     case '%':
//     {

//         if (y == 0)
//         {
//             cerr << "mod zero error!" << endl;
//             result = -1;
//         }
//         else
//             result = x % y;

//         // return x % y;
//     }
//     break;
//     default:
//         break;
//     }
//     return result;
// }

// class CalTask
// {
//     using func_t = std::function<int(int, int, char)>; // 这里也要加上一个char，不然回调函数和Main文件里面的my_math函数参数对不上
//     // typedef function<int(int, int)> func_t;

// public:
//     CalTask()
//     {
//     }
//     CalTask(int x, int y, char op, func_t func)
//         : _x(x),
//           _y(y),
//           _op(op),
//           _callback(func)
//     {
//     }
//     std::string operator()()
//     {
//         int result = _callback(_x, _y, _op);
//         char buffer[1024];
//         snprintf(buffer, sizeof(buffer), "%d %c %d = %d", _x, _op, _y, result);
//         return buffer;
//     }
//     std::string TaskToString()
//     {
//         char buffer[1024];
//         snprintf(buffer, 1024, "%d %c %d = ?", _x, _op, _y);
//         return buffer;
//     }
//     ~CalTask()
//     {
//     }

// private:
//     int _x;
//     int _y;
//     char _op;
//     func_t _callback;
// };

// // void savethread(const std::string &massage)
// // {
// //     const std::string target = "./log.tex";
// //     FILE *fp = fopen(target.c_str(), "a+");
// //     if (fp == nullptr)
// //     {
// //         cerr << "fopen file error!" << endl;
// //         return;
// //     }
// //     fputs(massage.c_str(), fp);
// //     fprintf(fp, "\n");
// //     fclose(fp);
// // }

// // class SaveTask
// // {
// //     typedef std::function<void(const std::string &)> func_t;

// // public:
// //     SaveTask()
// //     {
// //     }
// //     SaveTask(const std::string &massage, func_t func)
// //         : _massage(massage),
// //           _func(func)
// //     {
// //     }
// //     ~SaveTask()
// //     {
// //     }
// //     void operator()()
// //     {
// //         _func(_massage);
// //     }

// // private:
// //     std::string _massage;
// //     func_t _func;
// // };

#pragma once

#include <iostream>
#include <queue>
#include <pthread.h>
#include <functional>
#include <cstdio>
#include <cstring>

using namespace std;

void serverIO(int sock) // serverIO和服务端连接通信其实没什么关系，通信，业务逻辑处理解耦
{
    char buffer[1024];
    ////注意：未来我们线程池的业务逻辑处理不能是死循环！不然线程越来越少
    while (1)
    {
        ssize_t n = read(sock, buffer, sizeof(buffer) - 1);
        if (n > 0)
        {
            // 目前将读取的内容当作字符串
            buffer[n] = 0;
            cout << "recv message : " << buffer << endl;

            string outbuffer = "server[echo]";
            outbuffer += buffer;
            write(sock, outbuffer.c_str(), outbuffer.size()); // 服务端回应
        }
        else if (n == 0) // 表示客户端退出了！
        {
            logMessage(NORMAL, "client quit,me too");
            break;
        }
        else
        {
            cerr << sock << " read error!" << endl;
            break;
        }
        close(sock);//处理完的话，在内部就把套接字关闭
    }
}

class Task
{
    using func_t = std::function<void(int)>; // 回调函数，上面的serverIO

public:
    Task()
    {
    }
    Task(int sock, func_t func)
        : _sock(sock), _callback(func)
    {
    }
    void operator()()
    {
        _callback(_sock);
    }
    ~Task()
    {
    }

private:
    int _sock;
    func_t _callback;
};